linear_solver_interface.hpp

Go to the documentation of this file.

// Emacs Mode Line: -*- Mode:c++;-*-
// -------------------------------------------------------------

// -------------------------------------------------------------
// -------------------------------------------------------------
/**
 * @file   linear_solver_interface.hpp
 * @author William A. Perkins
 * @date   2015-08-14 14:51:30 d3g096
 * 
 * @brief  
 * 
 * 
 */
// -------------------------------------------------------------
// -------------------------------------------------------------
// Created October 21, 2014 by William A. Perkins
// Last Change: 2013-05-03 12:23:12 d3g096
// -------------------------------------------------------------


#ifndef _linear_solver_interface_hpp_
#define _linear_solver_interface_hpp_

#include "gridpack/math/matrix.hpp"

namespace gridpack {
namespace math {


// -------------------------------------------------------------
//  class BaseLinearSolverInterface
// -------------------------------------------------------------
template <typename T, typename I>
class BaseLinearSolverInterface 
//   : public ImplementationVisitable
{
public:

  typedef MatrixT<T, I> MatrixType;
  typedef VectorT<T, I> VectorType;

  /// Default constructor.
  BaseLinearSolverInterface(void)
  {}

  /// Destructor
  ~BaseLinearSolverInterface(void)
  {}

  /// Get the solution tolerance
  /** 
   * 
   * 
   * 
   * @return current solution tolerance
   */
  double tolerance(void) const
  {
    return this->p_tolerance();
  }

  /// Set the solver tolerance
  /** 
   * 
   * 
   * @param tol new solution tolerance
   */
  void tolerance(const double& tol)
  {
    this->p_tolerance(tol);
  }

  /// Get the maximum iterations
  /** 
   * 
   * 
   * 
   * @return current maximum number of solution iterations
   */
  int maximumIterations(void) const
  {
    return this->p_maximumIterations();
  }


  /// Set the maximum solution iterations
  /** 
   * 
   * 
   * @param n new maximum number of iterations
   */
  void maximumIterations(const int& n)
  {
    this->p_maximumIterations(n);
  }

  /// Solve w/ the specified RHS, put result in specified vector
  /** 
   * @e Collective.
   *
   * Solve a linear system of equations. When called, Vector @c x
   * should contain the initial solution estimate.  The final solution
   * is returned in @c x.  
   *
   * The \ref parallel::Communicator "communicator" @c x and @c b must
   * be the same and match that of the coefficient Matrix used for
   * construction. The length of both @c x and @c b must the number of
   * columns in the coeffienct Matrix used for constructor or passed
   * the last call to setMatrix().  If these conditions are not met,
   * an \ref Exception "exception" is thrown.
   *  
   * @param b Vector containing right hand side of linear system
   * @param x solution Vector
   */
  void solve(const VectorType& b, VectorType& x) const
  {
    this->p_solve(b, x);
  }

  /// Solve again w/ the specified RHS, put result in specified vector
  /** 
   * @e Collective.
   *
   * Solve a linear system of equations again with a different
   * RHS. This can only be called after ::solve() has been called once
   * and only if the coefficient matrix has not changed. Vector @c x
   * should contain the initial solution estimate.  The final solution
   * is returned in @c x.
   *
   * The \ref parallel::Communicator "communicator" @c x and @c b must
   * be the same and match that of the coefficient Matrix used for
   * construction. The length of both @c x and @c b must the number of
   * columns in the coeffienct Matrix used for constructor or passed
   * the last call to setMatrix().  If these conditions are not met,
   * an \ref Exception "exception" is thrown.
   *  
   * @param b Vector containing right hand side of linear system
   * @param x solution Vector
   */
  void resolve(const VectorType& b, VectorType& x) const
  {
    this->p_resolve(b, x);
  }

  /// Solve multiple systems w/ each column of the Matrix a single RHS
  /** 
   * 
   * 
   * @param B RHS matrix -- each column is used as a RHS Vector
   * 
   * @return @e dense solution Matrix -- each column is the solution for the corresponding column in @c B
   */
  MatrixType *solve(const MatrixType& B) const
  {
    return this->p_solve(B);
  }


protected:

  /// Get the solution tolerance (specialized)
  virtual double p_tolerance(void) const = 0;

  /// Set the solver tolerance (specialized)
  virtual void p_tolerance(const double& tol) = 0;

  /// Get the maximum iterations (specialized)
  virtual int p_maximumIterations(void) const = 0;

  /// Set the maximum solution iterations
  virtual void p_maximumIterations(const int& n) = 0;

  /// Solve w/ the specified RHS, put result in specified vector
  /** 
   * Can be called repeatedly with different @c b and @c x vectors
   * 
   * @param b Vector containing right hand side of linear system
   * @param x Vector containing initial solution estimate; final
   * solution is put into this.
   */
  virtual void p_solve(const VectorType& b, VectorType& x) const = 0;

  /// Solve again w/ the specified RHS, put result in specified vector
  /** 
   * This assumes that the coefficient matrix has not changed.  Can be
   * called repeatedly with different @c b and @c x vectors
   * 
   * @param b Vector containing right hand side of linear system
   * @param x Vector containing initial solution estimate; final
   * solution is put into this.
   */
  virtual void p_resolve(const VectorType& b, VectorType& x) const = 0;

  /// Solve multiple systems w/ each column of the Matrix a single RHS
  virtual MatrixType *p_solve(const MatrixType& B) const = 0;

};



} // namespace math
} // namespace gridpack


#endif

---